Table module compiler equivalent to ROM

ABSTRACT

A method of constructing a circuit for a Boolean function includes receiving as input a Boolean function of a number n of input variables wherein the number n of input variables may be varied over a range; generating at least two intermediate functions comprising sub-functions of the Boolean function wherein zero or one is substituted for all but two of the number n of input variables; and generating a selected output of the Boolean function of the number n of input variables from only two of the intermediate functions.

CROSS REFERENCE TO RELATED APPLICATIONS

[0001] This application is related to U.S. patent application Ser. No. 09/679,209 by Andreev, et. al. for “FAST FLEXIBLE SEARCH ENGINE FOR LONGEST PREFIX MATCH” filed on Oct. 4, 2000, incorporated herein by reference and assigned to the same assignee as the present invention; and U.S. patent application Ser. No. 09/679,313 by Andreev, et al. for “FLEXIBLE SEARCH ENGINE HAVING SORTED BINARY SEARCH TREE FOR PERFECT MATCH”, filed on Oct. 4, 2000, incorporated herein by reference and assigned to the same assignee as the present invention.

BACKGROUND OF THE INVENTION

[0002] The present invention is directed to methods for implementing function tables in integrated circuit designs. More specifically, but without limitation thereto, the present invention is directed to implementing a function table with random logic elements.

[0003] Designs often contain function tables, that is, tables of systems of Boolean operators, or functions, that are typically implemented in read-only memory (ROM). Examples of such tables may be found in U.S. patent application Ser. No. 09/679,209 by Andreev, et. al for “FAST FLEXIBLE SEARCH ENGINE FOR LONGEST PREFIX MATCH” filed on Oct. 4, 2000, and U.S. patent application Ser. No. 09/679,313 by Andreev, et al. for “FLEXIBLE SEARCH ENGINE HAVING SORTED BINARY SEARCH TREE FOR PERFECT MATCH”, filed on Oct. 4, 2000. For small tables that have from about 30 to 1,000 entries, implementing function tables in ROM becomes expensive. This is because ROM compilers create overhead such decoders and I/O pins that are independent of the number of words and bits. This overhead is relatively small for tables having more than 16,000 entries, but becomes extremely large for small tables. Another disadvantage in using ROM for small tables is that the floorplan and design flow of an integrated circuit are complicated by the use of ROM, since ROM megacells are typically placed manually, creating blockages for placement and routing of random logic cells.

SUMMARY OF THE INVENTION

[0004] In one aspect of the present invention, a method of constructing a circuit for a Boolean function includes receiving as input a Boolean function of a number n of input variables wherein the number n of input variables may be varied over a range; generating at least two intermediate functions comprising sub-functions of the Boolean function wherein zero or one is substituted for all but two of the number n of input variables; and generating a selected output of the Boolean function of the number n of input variables from only two of the intermediate functions.

[0005] In one embodiment, the number n of input variables may be varied over a range from two to twenty.

[0006] In another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, x₁, x₀) of the Boolean function and a equals zero or one; instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to the i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to a third input variable of the Boolean function to generate an AND-function of the third input variable and the i-th output; and instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two AND-functions generated by the cells in the second layer to generate an OR-function that is representative of the i-th output of the Boolean function of the number of input variables.

[0007] In still another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, b, x₁, x₀) of the Boolean function wherein {a, b} equals one of {0,0}, {0,1}, {1,0}, and {1,1} or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂) in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; and instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate the i-th output of the Boolean function of the number of input variables wherein u2=u % 256 and u3=u>>8.

[0008] In yet another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a_(n−1), . . . , a₂, x₁, x₀) of the Boolean function wherein a_(n−1), . . . , a₂ is a binary representation of each number in the range from zero to 2^(n−2)−1, or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a) _(n−1) _(, . . . , a) ₂ =fun_(1,1<<(1−a) _(n−1) ₎(x₃, x₂);

. . .

fun_(1,1<<(1−a) ₄ ₎(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a) _(n−1) _(, . . . , a) ₂ in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate each i-th output of an intermediate function fun_(4,u)(x₃, x₂, x₁, x₀) wherein u2=u % 256 and u3=u>>8; instantiating a fifth layer of cells wherein each of the cells has only two inputs coupled respectively to an i-th output of a decoder function fun_(1,1<<(1−a) _(n−1)) (x_(n−1))

. . .

fun_(1,1<<(1−a) ₀ ₎(x₀) wherein a_(n−1), . . . , a₀ is a binary representation of each number in the range from zero to 2^(n)−1 and to the i-th output of a sub-function fun_(4,u)(x₃, x₂, x₁, x₀) to generate an intermediate function ƒ₄ _(u) .

[0009] In another embodiment, the intermediate function ƒ₄ _(u) corresponds to the i-th output of the Boolean function of the number of input variables.

[0010] In still another embodiment, a method of constructing a circuit for a Boolean function includes instantiating an additional layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ_(k) _(u) in the previous layer to generate each i-th output of an intermediate function ƒ_(k+1) _(u) .

[0011] In yet another embodiment, the intermediate function ƒ_(k+1) _(u) corresponds to the i-th output of the Boolean function of the number of input variables.

DESCRIPTION OF THE DRAWINGS

[0012] The present invention is illustrated by way of example and not limitation in the accompanying figures, in which like references indicate similar elements throughout the several views of the drawings, and in which:

[0013]FIG. 1 illustrates an example of a table representative of a Boolean function of three input variables that may be compiled into random logic in accordance with an embodiment of the present invention;

[0014]FIG. 2 illustrates an example of the construction of a circuit for a Boolean function of two variables f_(i)(x₁, x₀) in accordance with an embodiment of the present invention; and

[0015]FIG. 3 illustrates a circuit for the Boolean table of FIG. 1 in accordance with an embodiment of the present invention.

[0016] Elements in the figures are illustrated for simplicity and clarity and have not necessarily been drawn to scale. For example, the dimensions of some of the elements in the figures may be exaggerated relative to other elements to help to improve understanding of the following description of the illustrated embodiments.

DESCRIPTION OF THE ILLUSTRATED EMBODIMENTS

[0017] In one aspect of the present invention, a method of constructing a circuit for a Boolean function includes receiving as input a Boolean function of a number n of input variables wherein the number n of input variables may be varied over a range; generating at least two intermediate functions comprising sub-functions of the Boolean function wherein zero or one is substituted for all but two of the number n of input variables; and generating a selected output of the Boolean function of the number n of input variables from only two of the intermediate functions. The sub-functions of the Boolean function are compiled in an array of discrete, two-input logic cells. In contrast to ROM megacells, these standard logic cells may be placed and routed automatically using readily available floorplan design tools.

[0018]FIG. 1 illustrates an example of a table 100 representative of a Boolean function of three input variables that may be compiled into random logic in accordance with an embodiment of the present invention. In this example, there are three input variables of the Boolean function, namely, X₀, X₁, and X₂, and the outputs of the function are f₀, f₁, and f₂. For each set of values for inputs X₀, X₁, and X₂, there is a corresponding set of output values for f₀, f₁, and f₂ defined by the Boolean table 100. In general, a Boolean operator or function may be expressed as a (N,m)-table defined for a set of N input vectors, where each input vector is a binary representation of a number less than N, and m is the number of outputs f₀, . . . , f_(m−1). For example, a (32,3)-table has three outputs f₀, f₁, and f₂ for 32 input vectors 0000, 0001, . . . , 1111. The (N,m)-table may be expressed as the Boolean operator or function (ƒ₀(x_(n−1), . . . , x₀), . . . , ƒ_(m−1)(x_(n−1), . . . , x₀)). Each input vector x_(n−1), . . . , x₀ is less than a number N, where n=uplog (N). The function uplog (x) is defined as the smallest integer not less than log₂(x). For the example of the (32,3)-table, n=uplog(N)=log₂32=5. The Boolean operator, or function, corresponds to the binary table T[0.N−1] [0.m−1] according to the formula:

T[i][j]=ƒ _(j)(a _(n−1) , . . . , a ₀)   (1)

[0019] where (a_(n−1), . . . , a₀) is the input vector corresponding to the binary representation of the number i, that is, each of the terms a_(n−1), . . . , a₀ of the input vector equals zero or one, and j=0, . . . , m−1, where m is the number of outputs for each input vector. For example, the terms in the input vector corresponding to the binary representation of the number 13 are a₃=1, a₂=1 , a₁=0, and a₀=1, and the output f₁ corresponding to the input vector 13 is represented by T[13][1]=ƒ₁(1,1,0,1).

[0020] In accordance with an embodiment of the present invention, a circuit is constructed for the operator (f₀, . . . , f_(m−1)) from the binary table T in formula (1) received as the compiler input. The optimization goals are minimum circuit depth, or layers, and a minimum number of cells required to construct the circuit. The following examples illustrate the construction of circuits entirely of standard cells each having only two inputs for Boolean functions having a number n of input variables that may be varied for Boolean functions having up to one million input vectors.

[0021] For values of N<=4, the value of 4 may be used without loss of generality to illustrate the most complex case where none of the outputs are constants and n=2. If an output is a constant, it may be generated without a logic cell, thereby reducing the number of cells in the circuit. Also, the number of cells in the circuit is reduced as the total percentage of zeroes or ones in the outputs f₁ approaches the extremes of zero or 100 percent.

[0022] In the example of N=4, any function f_(i) is a function of two variables as expressed by f_(i)(x₁, x₀) and may be performed by a standard library two-input cell such as AND, OR, XOR, and so on.

[0023]FIG. 2 illustrates an example of the construction of a circuit for a Boolean function of two variables f_(i)(x₁, x₀) in accordance with an embodiment of the present invention. Shown in FIG. 2 are inputs x₁ and x₀, two-input cells 202, 204, 206, and 208, and output functions f₀, f₁, f₂, and f_(m−1). In this case, the circuit has a single layer of logic, or depth, of one.

[0024] In another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, x₁, x₀) of the Boolean function and a equals zero or one; instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to the i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to a third input variable of the Boolean function to generate an AND-function of the third input variable and the i-th output; and instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two AND-functions generated by the cells in the second layer to generate an OR-function that is representative of the i-th output of the Boolean function of the number of input variables.

[0025] For values of N where 4<N<=8, the value of 8 may be used without loss of generality to illustrate the most complex case where none of the outputs are constants and n=3. In the example of N=8, any function f_(i) is a function of three variables as expressed by f_(i)(x₂, x₁, x₀).

[0026] A Boolean function f(x₂, x₁, x₀) may be represented by an integer function tab(ƒ) corresponding to the binary representation of the output vector. For example, in the table for the Boolean function in FIG. 1, the binary representation of the output vector f₀ is 00100001, and tab(ƒ₀)=21₁₆. The value of f for any input vector a_(n−1), . . . , a₀ corresponding to the binary representation of the number i may be found by right shifting tab(ƒ) by i bits and masking out all but the least significant bit, as may be expressed by the formula:

ƒ(a _(k−1) , . . . , a ₀)=(tab(ƒ)>>i) % 2   (2)

[0027] In the example of table 100 in FIG. 1, $\begin{matrix} \begin{matrix} {{{f_{0}\left( {1,0,1} \right)} = {{tab}\left( f_{0} \right)}}\operatorname{>>}{5\quad \% \quad 2}} \\ {{= 21_{16}}\operatorname{>>}{5\quad \% \quad 2}} \\ {= {1\quad \% \quad 2}} \end{matrix} & (3) \end{matrix}$

 =1

[0028] The function fun_(k,i) is defined as a Boolean function according to the formula:

fun _(k,i)=ƒ(x _(k−1) , . . . , x ₀)   (4)

[0029] such that tab(ƒ)=i, where i is an integer representative of the output vector. For example, the function fun_(2,1)(x₁, x₀) has the outputs f(0,0)=1, f(0,1)=0, f(1,0)=0, and f(1,1)=0.

[0030] The function g_(a,i)(x₁, x₀) is defined as the Boolean function f_(i)(a,x₁, x₀) according to the formula:

g _(a,i)(x ₁ , x ₀)=ƒ_(i)(a, x ₁ , x ₀)   (5)

[0031] where i=0, 1, . . . , m−1 and a has a value of zero or one.

[0032] A set G_(a) is defined as all the different numbers in the list generated by tab(g_(a,i)), where i=0, 1, . . . , m−1. The numbers zero and seven may be excluded from the list, because these functions may be represented by a zero or a one without requiring logic cells. Each value of tab(g_(a,i)) corresponds to a sub-function f_(i)(a, x₁, x₀). In the example of table 100 in FIG. 1, G₀={1,9,2} and G₁={2,1,3}.

[0033] A set G is defined as the union of the sets G_(a) by the formula:

G=G₀∪G₁   (6)

[0034] The circuit for the Boolean function f(x_(k−1), . . . , x₀) for 4<N<=8 may be constructed as follows. A first layer of logic corresponds to the set G and contains cells that generate the intermediate functions fun_(2,u)(x₁, x₀), where u=tab(ƒ_(i)) for each sub-function f_(i)(a, x₁, x₀) of the set G. In the example of table 100 in FIG. 1, the set G₀ is {1, 9, 2} and the set G₁ is {2, 1, 3}. The set G is therefore {1, 2, 3, 9}. Each two-input logic cell in the first layer of logic is accordingly selected to perform the intermediate functions fun_(2,1)(x₁, x₀), fun_(2,2)(x₁, x₀), fun_(2,3)(x₁, x₀), and fun_(2,9)(x₁, x₀), respectively.

[0035] A second layer of logic contains two groups. The first group contains the two-input cells that generate the intermediate functions ˜x₂

fun_(2,u0)(x₁, x₀), where u0 is each sub-function f_(i)(0,x₁, x₀) of the set G₀. In this example, the first group contains the cells that generate the intermediate functions ˜x₂

fun_(2,1)(x₁, x₀), ˜x₂

fun_(2,9)(x₁, x₀), and ˜x₂

fun_(2,2)(x₁, x₀), respectively. The second group contains the cells that generate the intermediate functions x₂

fun_(2,u1)(x₁, x₀), where u1 is each sub-function f_(i)(1,x₁, x₀) of the set G₁. In this example, the second group contains the cells that generate the intermediate functions x₂

fun_(2,2)(x₁, x₀), x₂

fun_(2,1)(x₁, x₀), and x₂

fun_(2,3)(x₁, x₀), respectively.

[0036] A third layer of logic computes the Boolean operator according to the formula:

ƒ_(i)(x ₂ , x ₁ , x ₀)=(˜x ₂

fun _(2,u0)(x ₁ , x ₀))

(x ₂

fun _(2,u1)(x ₁ , x ₀))   (7)

[0037] where u0=tab(ƒ_(i)(0, x₁, x₀)), u1=tab(ƒ_(i)(1, x₁, x₀)), and i=0, 1, . . . , m−1. In this example, the third layer contains the two-input cells that generate the Boolean function for the three input variables as follows: $\begin{matrix} \begin{matrix} {f_{0} = {\left( {{\sim x_{2}}{{fun}_{2,1}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,2}\left( {x_{1},x_{0}} \right)}} \right)}} \\ {f_{1} = {\left( {{\sim x_{2}}{{fun}_{2,9}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,1}\left( {x_{1},x_{0}} \right)}} \right)}} \\ {f_{2} = {\left( {{\sim x_{2}}{{fun}_{2,2}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,3}\left( {x_{1},x_{0}} \right)}} \right)}} \end{matrix} & (8) \end{matrix}$

[0038] The three layers of logic described above define a depth of three for this circuit.

[0039]FIG. 3 illustrates a circuit for the Boolean table of FIG. 1 in accordance with an embodiment of the present invention. Shown in FIG. 3 are input variables x₂, x₁, and x₀, a first logic layer 302, first layer cells 304, 306, 308, and 310, a second logic layer 312, second layer cells 314, 316, 318, 320, 322, and 324, a third logic layer 326, third layer logic cells 328, 330, and 332, and Boolean function outputs f₀, f₁, and f₂.

[0040] The first layer cells 304, 306, 308, and 310 generate the functions fun_(2,1)(x₁, x₀), fun_(2,2)(x₁, x₀), fun_(2,3)(x₁, x₀), and fun_(2,9)(x₁, x₀) described above for formula (6). The second layer cells 314, 316, and 318 generate the functions ˜x₂

fun_(2,1)(x₁, x₀), ˜x₂

fun_(2,9)(x₁, x₀), and ˜x₂

fun_(2,2)(x₁, x₀), respectively. The second layer cells 320, 322, and 324 generate the functions x₂

fun_(2,2)(x₁, x₀), x₂

fun_(2,1)(x₁, x₀), and x₂

fun_(2,3)(x₁, x₀), respectively. The third layer logic cells 328, 330, and 332 generate the functions $\begin{matrix} {{{f_{0} = {\left( {{\sim x_{2}}{{fun}_{2,1}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,2}\left( {x_{1},x_{0}} \right)}} \right)}},}\quad} \\ {{{f_{1} = {\left( {{\sim x_{2}}{{fun}_{2,9}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,1}\left( {x_{1},x_{0}} \right)}} \right)}},{and}}\quad} \\ {{f_{2} = {\left( {{\sim x_{2}}{{fun}_{2,2}\left( {x_{1},x_{0}} \right)}} \right)\left( {x_{2}{{fun}_{2,3}\left( {x_{1},x_{0}} \right)}} \right)}},{{respectively}.}} \end{matrix}$

[0041] In still another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, b, x₁, x₀) of the Boolean function wherein {a, b} equals one of {0,0}, {0,1}, {1,0}, and {1,1} or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂) in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; and instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate the i-th output of the Boolean function of the number of input variables wherein u2=u % 256 and u3=u>>8.

[0042] For values of N where 8<N<=16, the value of 16 may be used without loss of generality to illustrate the most complex case where none of the output functions are constants and n=4.

[0043] A set F_(i) is defined as all the different numbers in the list generated by tab(ƒ_(i)) except the constants zero and fifteen, which do not require logic cells, where i=0, 1, . . . , m−1.

[0044] A set F_(a,i) is defined as all the different numbers in the list generated by tab(ƒ_(i)(a, x₂, x₁, x₀) except the constants zero and fifteen, where i=0, 1, . . . , m−1 and a equals zero or one.

[0045] A set F_(a,b) is defined as all the different numbers in the list generated by tab(ƒ_(i)(a, b, x₂, x₁, x₀) except the constants zero and fifteen, where i=0, 1, . . . , m−1, a equals zero or one, and b equals zero or one.

[0046] A set G is defined as the union of the sets F_(a,b) according to the formula:

G=F_(0,0)∪F_(0,1)∪F_(1,0)∪F_(1,1)   (9)

[0047] The circuit for the Boolean function f(x_(k−1), . . . , x₀) for 8<N<=16 may be constructed as follows. A first layer of logic includes the intermediate functions fun_(2,u)(x₁, x₀), where u is each sub-function from the set G_(i). The first layer of logic also includes the intermediate functions K_(a,b) defined by the formula:

K _(a,b) =fun _(2,1<<(2a+b))(x ₃ , x ₂)   (10)

[0048] where a equals zero or one and b equals zero or one. Equivalently, K_(a,b) may be expressed by the formula:

K _(a,b) =fun _(1,1<<1−a)(x ₃)

fun _(1,1<<1−b)(x ₂)   (11)

[0049] where

fun _(1,1<<0)(x)=˜x   (12)

fun _(1,1<<1)(x)=x   (13)

[0050] A second layer of logic contains the intermediate functions defined by the formula:

ƒ₂ _(a,b,u) =K _(a,b)

fun _(2,u)(x ₁ , x ₀)   (14)

[0051] for each pair (a,b) where u is each sub-function of the set F_(a,b).

[0052] A third layer of logic includes the intermediate functions ƒ₃ _(a,u,i) , where u is each sub-function from the set F_(a) and a equals zero or one. Each third layer function is the result of an OR function of two second layer functions according to the formula:

ƒ₃ _(a,u) =ƒ₂ _(a,0,u0)

ƒ₂ _(a,1,u1)   (15)

[0053] where u0=u % 16 and u1=u>>4.

[0054] A fourth layer contains the outputs of the Boolean operator (f₀, . . . , f_(m−1)) Each function in the fourth layer is the result of an OR function of two functions in the third layer according to the formula:

ƒ_(i)(x ₃ , x ₂ , x ₁ , x ₀)=fun _(4,u)=ƒ₃ _(0,u0)

ƒ₃ _(1,u1)   (16)

[0055] where u=tab(ƒ_(i)), u0=u % 256, and u1=u>>8. The four layers of logic define a depth of four for this circuit.

[0056] In yet another embodiment, a method of constructing a circuit for a Boolean function includes instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a_(n−1), . . . , a₂, x₁, x₀) of the Boolean function wherein an a_(n−1), . . . , a₂ is a binary representation of each number in the range from zero to 2^(n−2)−1, or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a) _(n−1) _(, . . . , a) ₂ =fun_(1,1<<(1−a) _(n−1) ₎(x₃, x₂)

. . .

fun_(1,1<<(1−a) ₄ ₎(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a) _(n−1) _(, . . . , a) ₂ in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate each i-th output of an intermediate function fun_(4,u)(x₃, x₂, x₁, x₀) wherein u2=u % 256 and u3=u>>8; instantiating a fifth layer of cells wherein each of the cells has only two inputs coupled respectively to an i-th output of a decoder function fun_(1,1<<(1−a) _(n−1) ₎(x_(n−1))

. . .

fun_(1,1<<(1−a) ₀ ₎(x₀) wherein a_(n−1), . . . , a₀ is a binary representation of each number in the range from zero to 2^(n)−1 and to the i-th output of a sub-function fun_(4,u)(x₃, x₂, x₁, x₀) to generate an intermediate function ƒ₄ _(u) .

[0057] A decoder D(x_(n−1), . . . , x₀) is a Boolean operator that realizes the following system of functions:

fun _(1,1<<a) _(n−1)

fun _(1,1<<a) _(n−2)

. . .

fun _(1,1<<a) ₀   (17)

[0058] where the input vectors (x_(n−1), . . . , x₀) are all combinations of each of the terms a_(n−1), . . . , a₀ where each term equals zero or one. To implement the decoder D(x_(n−1), . . . , x₀), two sub-decoders, D(x_(n−1), . . . , x_(k)) and D(x_(k−1), . . . , x₀) may be constructed, where k=n/2. Any function of the decoder D(x_(n−1), . . . , x₀) may be expressed as the result of an AND function of the first and second sub-decoders D(x_(n−1), . . . , x_(k)) and D(x_(k−1), . . . , x₀). Consequently, the depth of the decoder is given by the formula:

depth(n)≦1+max(depth(n−k),depth(k))   (18)

[0059] where depth(n) is the minimum possible depth of the decoder D (x_(n−1), . . . , x₀). Using the recursive construction described above, the depth of the decoder D(x_(n−1), . . . , x₀) is given by the formula:

depth(N)=uplog(N)   (19)

[0060] where N is the number of input vectors. In this example, the depth is depth(16)=uplog(16)=4. For example, a 2-input input decoder may be realized by K_(a,b) as described above with reference to formula (11).

[0061] For values of N where 16<N<=1M, a set F is defined that contains all the different numbers in the list generated by tab(ƒ_(i)) except the constants zero and (N−1), where i=0, 1, . . . , m−1.

[0062] A set F_(a) _(n−1) _(, . . . , a) ₄ is defined that contains all the different numbers in the list generated by tab(ƒ_(i)(a_(n−1), . . . , a₄, x₃, . . . , x₀)) except the constants zero and (N−1), where i=0, 1, . . . , m−1 and each of the terms a_(n−1), . . . , a_(k) equals zero or 1.

[0063] A set G is defined as the union of all sets F_(a) _(n−1) _(, . . . , a) ₄ .

[0064] The circuit for the function system fun_(4,u), where u equals each value of tab(ƒ_(i)) from G, is constructed as described above with reference to formula (16) for the case where 8<N<=16. The depth of this circuit is 4.

[0065] Next, a circuit for the decoder D (x_(n−1), . . . , x₄) is constructed as described above to generate the intermediate functions fun_(1,1<<a) _(n−1)

fun_(1,1<<a) _(n−2)

. . .

fun_(1,1<<a) ₀ . The decoder D(x_(n−1), . . . , x₄) has a depth of at most 4, because n<=uplog(1M)−4=20−4=16 and depth(N)=uplog(N)=4.

[0066] A fifth logic layer includes the intermediate functions:

fun _(1,1<<a) _(n−1)

fun _(1,1<<a) _(n−2)

. . .

fun _(1,1<<a) ₀

ƒ _(i)(a _(n−1) , . . . a ₄ , x ₃ , x ₂ , x ₁ , x ₀)   (20)

[0067] where i=0, 1, . . . , m−1 and the terms a_(n−1), . . . , a₀ are each zero or one.

[0068] For each sequence (a_(n−1), . . . , a_(k)) and sub-function u from the set F_(a) _(n−1) _(, . . . , a) _(k) , a logic cell to generate the intermediate function ƒ_(k) _(n) is instantiated. For the example where k=4,

ƒ₄ _(u) =fun _(1,1<<a) _(n−1)

fun _(1,1<<a) _(n−2)

. . .

fun _(1,1<<a) ₀

fun ₄ _(u)   (21)

[0069] where u=tab(ƒ_(i)). The functions in formula (21) are those constructed in formula (20).

[0070] A sub-function u from the set F_(a) _(n−1) _(, . . . , a) ₅ and functions u0 and u1 from the set F_(a) _(n−1) _(, . . . , a) ₄ are selected such that u=u0+(u1<<(2{circumflex over ( )}k)), where u=tab(ƒ_(i)). Then

ƒ₅ _(u) =ƒ₄ _(u0)

ƒ₄ _(u1)   (22)

[0071] The functions ƒ₅ _(u) and u from F_(a) _(n−1) _(, . . . , a) ₄ are in the fifth logic layer. In general, additional layers of cells may be instantiated wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ_(k) _(u) in the previous layer to generate each i-th output of an intermediate function ƒ_(k+1) _(u) . Any function f_(i) of the input function is an OR function of two functions according to the formula:

ƒ_(i)=ƒ_((n−1)) _(u0)

ƒ_((n−1)) _(u1)   (23)

[0072] The depth of the circuit required to implement the input function is (n+1).

[0073] The embodiments of the present invention described above may be used to compile tables more efficiently than ROM for tables having fewer than a million entries. In contrast to some circuits that may be applicable to Boolean functions having a single number of input variables, such as four or five, or a narrow range of numbers of input variables, such as from four to eight, the embodiments of the present invention described above may be used with Boolean functions of a number of input variables wherein the number of input variables may vary over a range from 2¹ to 2²⁰.

[0074] While the invention herein disclosed has been described by means of specific embodiments and applications thereof, numerous modifications and variations could be made thereto by those skilled in the art without departing from the scope of the invention set forth in the following claims. 

What is claimed is:
 1. A method of constructing a circuit for a Boolean function comprising: receiving as input a Boolean function of a number n of input variables wherein the number n of input variables may be varied over a range; generating at least two intermediate functions comprising sub-functions of the Boolean function wherein zero or one is substituted for all but two of the number n of input variables; and generating a selected output of the Boolean function of the number n of input variables from only two of the intermediate functions.
 2. The method of claim 1 wherein the number n of input variables may be varied over a range from two to twenty.
 3. The method of claim 1 comprising: instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, x₁, x₀) of the Boolean function and a equals zero or one; instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to the i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to a third input variable of the Boolean function to generate an AND-function of the third input variable and the i-th output; and instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two AND-functions generated by the cells in the second layer to generate an OR-function that is representative of the i-th output of the Boolean function of the number of input variables.
 4. The method of claim 1 comprising: instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, b, x₁, x₀) of the Boolean function wherein {a,b} equals one of {0,0}, {0,1}, {1,0}, and {1,1} or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂) in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; and instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate the i-th output of the Boolean function of the number of input variables wherein u2=u % 256 and u3=u>>8.
 5. The method of claim 1 comprising: instantiating a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a_(n−1), . . . , a₂, x₁, x₀) of the Boolean function wherein a_(n−1), . . . , a₂ is a binary representation of each number in the range from zero to 2^(n−2)−1, or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a) _(n−1) _(, . . . , a) ₂ =fun_(1,1<<(1−a) _(n−1) ₎(x₃, x₂)

. . .

fun_(1,1<<(1−a) ₄ ₎(x₃, x₂); instantiating a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a) _(n−1) _(, . . . , a) ₂ in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; instantiating a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; instantiating a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate each i-th output of an intermediate function fun_(4,u)(x₃, x₂, x₁, x₀) wherein u2=u % 256 and u3=u>>8; and instantiating a fifth layer of cells wherein each of the cells has only two inputs coupled respectively to an i-th output of a decoder function fun_(1,1<<(1−a) _(n−1) ₎(x_(n−1))

. . .

fun_(1,1<<(1−a) ₀ ₎(x₀) wherein a_(n−1), . . . , a₀ is a binary representation of each number in the range from zero to 2^(n)−1 and to the i-th output of a sub-function fun_(4,u)(x₃, x₂, x₁, x₀) to generate an intermediate function ƒ₄ _(u) .
 6. The method of claim 5 wherein the intermediate function ƒ₄ _(u) corresponds to the i-th output of the Boolean function of the number of input variables.
 7. The method of claim 5 comprising instantiating an additional layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ_(k) _(u) in the previous layer to generate each i-th output of an intermediate function ƒ_(k+1) _(u) .
 8. The method of claim 7 wherein the intermediate function ƒ_(k+1) _(u) corresponds to the i-th output of the Boolean function of the number of input variables.
 9. A circuit for a Boolean function of a number n of input variables comprising: a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, x₁, x₀) of the Boolean function and a equals zero or one; a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to the i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to a third input variable of the Boolean function to generate an AND-function of the third input variable and the i-th output; and a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two AND-functions generated by the cells in the second layer to generate an OR-function that is representative of the i-th output of the Boolean function of the number of input variables.
 10. A circuit for a Boolean function of a number n of input variables comprising: a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a, b, x₁, x₀) of the Boolean function wherein {a,b} equals one of {0,0}, {0,1}, {1,0}, and {1,1} or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂); a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a,b)=fun_(2,1<<(2a+b))(x₃, x₂) in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; and a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate the i-th output of the Boolean function of the number of input variables wherein u2=u % 256 and u3=u>>8.
 11. A circuit for a Boolean function of a number n of input variables comprising: a first layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively either to first and second input variables x₀ and x₁ of the Boolean function to generate sub-functions fun_(2,u)(x₁, x₀) each having an output vector equal to u wherein u is an integer corresponding to a binary representation of an i-th output ƒ_(i)(a_(n−1), . . . , a₂, x₁, x₀) of the Boolean function wherein a_(n−1), . . . , a₂ is a binary representation of each number in the range from zero to 2^(n−2)−1, or to second and third input variables x₂ and x₃ of the Boolean function to generate sub-functions K_(a) _(n−1) _(, . . . , a) ₂ =fun_(1,1<<(1−a) _(n−1) ₎(x₃, x₂)

. . .

fun_(1,1<<(1−a) ₄ ₎(x₃, x₂); a second layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to an i-th output of one of the sub-functions fun_(2,u)(x₁, x₀) in the first layer and to one of the sub-functions K_(a) _(n−1) _(, . . . , a) ₂ in the first layer to generate an intermediate function ƒ₂ _(a,b,u) for each of the cells in the second layer; a third layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₂ _(a,b,u0) and ƒ₂ _(a,b,u1) in the second layer to generate an intermediate function ƒ₃ _(a,u) in the third layer wherein u0=u % 16 and u1=u>>4; a fourth layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ₃ _(a,u2) and ƒ₃ _(a,u3) in the third layer to generate each i-th output of an intermediate function fun_(4,u)(x₃, x₂, x₁, x₀) wherein u2=u % 256 and u3=u>>8; and a fifth layer of cells wherein each of the cells has only two inputs coupled respectively to an i-th output of a decoder function fun_(1,1<<(1−a) _(n−1) ₎(x_(n−1))

. . .

fun_(1,1<<(1−a) ₀ ₎(x₀) wherein a_(n−1), . . . , a₀ is a binary representation of each number in the range from zero to 2^(n)−1 and to the i-th output of a sub-function fun_(4,u)(x₃, x₂, x₁, x₀) to generate an intermediate function ƒ₄ _(u) .
 12. The circuit of claim 11 wherein the intermediate function ƒ₄ _(u) corresponds to the i-th output of the Boolean function of the number n of input variables.
 13. The circuit of claim 11 comprising an additional layer of cells wherein each of the cells has only two inputs, and the two inputs are coupled respectively to two intermediate functions ƒ_(k) _(u) in the previous layer to generate each i-th output of an intermediate function ƒ_(k+1) _(u) .
 14. The method of claim 13 wherein the intermediate function ƒ_(k+1) _(n) corresponds to the i-th output of the Boolean function of the number of input variables. 